package kd.bos.openapi.demo.sample.operation.service.impl;

import com.alibaba.fastjson.JSON;
import kd.bos.openapi.demo.sample.operation.service.OrderService;
import kd.bos.openapi.sdk.dto.OrderDto;
import kd.bos.openapi.sdk.exception.APIException;
import kd.bos.openapi.sdk.request.RequestOperatorDto;
import kd.bos.openapi.sdk.request.RequestQueryDto;
import kd.bos.openapi.sdk.response.APIResponseDto;
import kd.bos.openapi.sdk.response.query.ResponseQueryDto;
import kd.bos.openapi.sdk.response.result.ResultCode;
import kd.bos.openapi.sdk.response.save.ResponseSaveDto;
import kd.bos.openapi.sdk.util.OpenApiUtil;
import kd.bos.openapi.sdk.util.PropertyUtil;
import kd.bos.openapi.sdk.util.StringUtils;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Map;

/**
 * @Deacription 操作类API服务订单服务接口
 * @author johnzou
 * @date 2022年4月6日
 */
@Slf4j
public class OrderServiceImpl implements OrderService {

    /**
     * 查找订单  比如：billno=003
     * @param billno 查询订单参数
     * @return 订单列表
     * @throws Exception 异常
     */
    @Override
    public String findOrdersByBillno(String billno) throws APIException {
        log.info("request.data:{}", billno);
        if (StringUtils.isEmpty(billno)) {
            // 参数非法，异常
            return null;
        }
        // 查询参数
        Map<String,Object> params = new HashMap<>();
        params.put("billno",billno);
        params.put("pageSize","10");
        params.put("pageNo","1");
        // 查询URL
        String sortUrl = PropertyUtil.getProperty("bos.order.findOrdersByGet");
        // 请求处理
        String res = OpenApiUtil.doGet(sortUrl, params);
        // res是请求json字符串，可以根据业务需要转成对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        return res;
    }

    /**
     * 查找订单  比如：billno=003， pageSize=10， pageNo=1
     * @param queryParams 查询订单参数
     * @return 订单列表
     * @throws Exception 异常
     */
    @Override
    public APIResponseDto findOrdersByGet(Map<String, Object> queryParams) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(queryParams));
        if (queryParams == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 获取查询结果
        String sortUrl = PropertyUtil.getProperty("bos.order.findOrdersByGet");
        // 请求结果
        String res = OpenApiUtil.doGet(sortUrl, queryParams);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseQueryDto<OrderDto> responseDto = ResponseQueryDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseDto = JSON.parseObject(res, ResponseQueryDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        return APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseDto.getData());
    }

    /**
     * 查找订单
     * @param orderRequestDto 查询订单参数
     * @return 订单列表
     * @throws Exception 异常
     */
    @Override
    public APIResponseDto findOrders(RequestQueryDto<OrderDto> orderRequestDto) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(orderRequestDto));
        if (orderRequestDto == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 获取查询结果
        String sortUrl = PropertyUtil.getProperty("bos.order.findOrders");
        // 请求结果
        String res = OpenApiUtil.doPostByJson(sortUrl, orderRequestDto);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseQueryDto<OrderDto> responseDto = ResponseQueryDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseDto = JSON.parseObject(res, ResponseQueryDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        return APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseDto.getData());
    }

    /**
     * 保存订单
     * @param order 订单
     * @return 保存后信息
     * @throws APIException 异常
     */
    @Override
    public APIResponseDto saveOrder(RequestOperatorDto<OrderDto> order) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(order));
        if (order == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 请求URL
        String sortUrl = PropertyUtil.getProperty("bos.order.saveOrder");
        // 获取处理结果
        String res = OpenApiUtil.doPostByJson(sortUrl, order);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseSaveDto responseSaveDto = ResponseSaveDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseSaveDto = JSON.parseObject(res, ResponseSaveDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        APIResponseDto apiResponseDto = null;
        if (responseSaveDto.getStatus()) {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseSaveDto);
        } else {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.UNKNOWN_EXCEPTION).of(responseSaveDto);
        }
        return apiResponseDto;
    }

    /**
     * 提交订单
     * @param order 订单
     * @return 提交后信息
     * @throws APIException 异常
     */
    @Override
    public APIResponseDto submitOrder(RequestOperatorDto<OrderDto> order) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(order));
        if (order == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 请求URL
        String sortUrl = PropertyUtil.getProperty("bos.order.submitOrder");
        // 获取处理结果
        String res = OpenApiUtil.doPostByJson(sortUrl, order);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseSaveDto responseSaveDto = ResponseSaveDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseSaveDto = JSON.parseObject(res, ResponseSaveDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        APIResponseDto apiResponseDto = null;
        if (responseSaveDto.getStatus()) {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseSaveDto);
        } else {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.UNKNOWN_EXCEPTION).of(responseSaveDto);
        }
        return apiResponseDto;
    }

    /**
     * 撤销订单
     * @param order 订单
     * @return 提交后信息
     * @throws APIException 异常
     */
    @Override
    public APIResponseDto unSubmitOrder(RequestOperatorDto<OrderDto> order) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(order));
        if (order == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 请求URL
        String sortUrl = PropertyUtil.getProperty("bos.order.unSubmitOrder");
        // 获取处理结果
        String res = OpenApiUtil.doPostByJson(sortUrl, order);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseSaveDto responseSaveDto = ResponseSaveDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseSaveDto = JSON.parseObject(res, ResponseSaveDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        APIResponseDto apiResponseDto = null;
        if (responseSaveDto.getStatus()) {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseSaveDto);
        } else {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.UNKNOWN_EXCEPTION).of(responseSaveDto);
        }
        return apiResponseDto;
    }

    /**
     * 审核订单
     * @param order 订单
     * @return 审核后信息
     * @throws APIException 异常
     */
    @Override
    public APIResponseDto auditOrder(RequestOperatorDto<OrderDto> order) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(order));
        if (order == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 请求URL
        String sortUrl = PropertyUtil.getProperty("bos.order.auditOrder");
        // 获取处理结果
        String res = OpenApiUtil.doPostByJson(sortUrl, order);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseSaveDto responseSaveDto = ResponseSaveDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseSaveDto = JSON.parseObject(res, ResponseSaveDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        APIResponseDto apiResponseDto = null;
        if (responseSaveDto.getStatus()) {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseSaveDto);
        } else {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.UNKNOWN_EXCEPTION).of(responseSaveDto);
        }
        return apiResponseDto;
    }

    /**
     * 反审核订单
     * @param order 订单
     * @return 反审核后信息
     * @throws APIException 异常
     */
    @Override
    public APIResponseDto unAuditOrder(RequestOperatorDto<OrderDto> order) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(order));
        if (order == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 请求URL
        String sortUrl = PropertyUtil.getProperty("bos.order.unAuditOrder");
        // 获取处理结果
        String res = OpenApiUtil.doPostByJson(sortUrl, order);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseSaveDto responseSaveDto = ResponseSaveDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseSaveDto = JSON.parseObject(res, ResponseSaveDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        APIResponseDto apiResponseDto = null;
        if (responseSaveDto.getStatus()) {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseSaveDto);
        } else {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.UNKNOWN_EXCEPTION).of(responseSaveDto);
        }
        return apiResponseDto;
    }

    /**
     * 删除订单
     * @param order 订单
     * @return 删除后信息
     * @throws APIException 异常
     */
    @Override
    public APIResponseDto deleteOrder(RequestOperatorDto<OrderDto> order) throws APIException {
        log.info("request.data:{}", JSON.toJSONString(order));
        if (order == null) {
            // 参数非法，异常
            return APIResponseDto.createRequest(ResultCode.BUSINESS_PARAM_NULL_EXCEPTION);
        }
        // 请求URL
        String sortUrl = PropertyUtil.getProperty("bos.order.deleteOrder");
        // 获取处理结果
        String res = OpenApiUtil.doPostByJson(sortUrl, order);
        // 构建请求响应对象，根据返回的errorCode做不同的业务处理
        // 具体的errorCode,可以参考 kd.bos.openapi.common.constant.ApiErrorCode
        ResponseSaveDto responseSaveDto = ResponseSaveDto.create();
        if (!StringUtils.isEmpty(res)) {
            responseSaveDto = JSON.parseObject(res, ResponseSaveDto.class);
        }
        // 此处根据其他模块调用的需要封装结果，现在以返回Controller为例
        APIResponseDto apiResponseDto = null;
        if (responseSaveDto.getStatus()) {
            apiResponseDto = APIResponseDto.createRequest(ResultCode.SUCCESS).of(responseSaveDto);
        } else {
            apiResponseDto = APIResponseDto.createRequestByMessage(ResultCode.UNKNOWN_EXCEPTION, responseSaveDto.getMessage()).of(responseSaveDto);
        }
        return apiResponseDto;
    }
}
